package model

import (
	"fmt"
	"strings"
)

// 支持的运算符（按优先级排序，长运算符优先检测）
const (
	opContains    = "contains" // 包含运算符
	opNotContains = "!contains"
	opEqual       = "==" // 等于运算符
	opNotEqual    = "!=" // 不等于运算符
)

// isTaskShouldRun 检查任务是否满足执行条件，支持 ==、!=、contains 运算符
// 支持格式：
// - "os == 'ubuntu'"       ：判断os是否等于ubuntu
// - "ip != '192.168.1.1'" ：判断ip是否不等于192.168.1.1
// - "os contains 'ubuntu'"：判断os是否包含ubuntu子串
// - "ip contains '192.168'"：判断ip是否包含192.168子串
func isTaskShouldRun(when string) (bool, error) {
	expr := strings.TrimSpace(when)
	lowerExpr := strings.ToLower(expr)
	// 步骤1：解析运算符和左右值
	op, left, right, err := parseOperatorAndValues(lowerExpr)
	if err != nil {
		return false, err
	}

	// 步骤2：根据运算符执行判断
	switch op {
	case opEqual:
		return left == right, nil
	case opNotEqual:
		return left != right, nil
	case opContains:
		// 包含判断（忽略大小写）
		return strings.Contains(left, right), nil
	case opNotContains:
		return !strings.Contains(left, right), nil
	default:
		return false, fmt.Errorf("不支持的运算符: %s", op)
	}
}

// parseOperatorAndValues 解析表达式中的运算符、左值和右值
func parseOperatorAndValues(expr string) (op, left, right string, err error) {
	// 优先检测最长运算符!contains，避免被其他运算符误判
	if strings.Contains(expr, opNotContains) {
		op = opNotContains
		parts := strings.SplitN(expr, opNotContains, 2)
		if len(parts) != 2 {
			return "", "", "", fmt.Errorf("!contains 表达式格式错误: %s（正确格式：'key !contains value'）", expr)
		}
		left = strings.TrimSpace(parts[0])
		right = trimQuotes(strings.TrimSpace(parts[1]))
		return op, left, right, nil
	} else if strings.Contains(expr, opContains) {
		op = opContains
		parts := strings.SplitN(expr, opContains, 2)
		if len(parts) != 2 {
			return "", "", "", fmt.Errorf("contains 表达式格式错误: %s（正确格式：'key contains value'）", expr)
		}
		left = strings.TrimSpace(parts[0])
		right = trimQuotes(strings.TrimSpace(parts[1]))
		return op, left, right, nil
	} else if strings.Contains(expr, opEqual) {
		op = opEqual
		parts := strings.SplitN(expr, opEqual, 2)
		if len(parts) != 2 {
			return "", "", "", fmt.Errorf("== 表达式格式错误: %s（正确格式：'key == value'）", expr)
		}
		left = strings.TrimSpace(parts[0])
		right = trimQuotes(strings.TrimSpace(parts[1]))
		return op, left, right, nil
	} else if strings.Contains(expr, opNotEqual) {
		op = opNotEqual
		parts := strings.SplitN(expr, opNotEqual, 2)
		if len(parts) != 2 {
			return "", "", "", fmt.Errorf("!= 表达式格式错误: %s（正确格式：'key != value'）", expr)
		}
		left = strings.TrimSpace(parts[0])
		right = trimQuotes(strings.TrimSpace(parts[1]))
		return op, left, right, nil
	}

	return "", "", "", fmt.Errorf("未找到支持的运算符（支持 !contains/contains/==/!=）: %s", expr)
}

// trimQuotes 去除字符串前后的单引号或双引号
func trimQuotes(s string) string {
	if len(s) >= 2 {
		if (s[0] == '"' && s[len(s)-1] == '"') || (s[0] == '\'' && s[len(s)-1] == '\'') {
			return s[1 : len(s)-1]
		}
	}
	return s
}
